home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / pluginy Firefox / 8352 / 8352.xpi / components / gfTestHarnessCommandLineHandler.js < prev    next >
Text File  |  2009-05-24  |  15KB  |  440 lines
  1. /*
  2.  * Copyright (C) 2008 by Steve Krulewitz <skrulx@gmail.com>
  3.  * Licensed under GPLv2 or later, see file LICENSE in the xpi for details.
  4.  */
  5. const Cc = Components.classes;
  6. const Ci = Components.interfaces;
  7. const Cr = Components.results;
  8.  
  9. function d(s) {
  10.   dump("gfTestHarnessCommandLineHandler: " + s + "\n");
  11. }
  12.  
  13. function gfTestHarnessRunEnvironment() {
  14. }
  15.  
  16. gfTestHarnessRunEnvironment.prototype.log =
  17. function gfTestHarnessRunEnvironment_log(s)
  18. {
  19.   dump("[log] " + s + "\n");
  20. }
  21.  
  22. gfTestHarnessRunEnvironment.prototype.newURI =
  23. function gfTestHarnessRunEnvironment_newURI(aSpec)
  24. {
  25.   var ios = Components.classes["@mozilla.org/network/io-service;1"]
  26.                       .getService(Components.interfaces.nsIIOService);
  27.   return ios.newURI(aSpec, null, null);
  28. }
  29.  
  30. gfTestHarnessRunEnvironment.prototype.assertEqual =
  31. function gfTestHarnessRunEnvironment_assertEqual(a, b)
  32. {
  33.   if (a != b) {
  34.     this.error("Values are not equal, '" + a + "' != '" + b + "'");
  35.   }
  36. }
  37.  
  38. gfTestHarnessRunEnvironment.prototype.assertTrue =
  39. function gfTestHarnessRunEnvironment_assertTrue(a)
  40. {
  41.   if (!a) {
  42.     this.error("Value is not true");
  43.   }
  44. }
  45.  
  46. gfTestHarnessRunEnvironment.prototype.error =
  47. function gfTestHarnessRunEnvironment_error(aMessage)
  48. {
  49.   this.log("ERROR: " + aMessage);
  50.   var stack = Components.stack;
  51.   while (stack) {
  52.     this.log("  " + stack);
  53.     stack = stack.caller;
  54.   }
  55.   throw Cr.NS_ERROR_ILLEGAL_VALUE;
  56. }
  57.  
  58. function gfTestHarnessCommandLineHandler()
  59. {
  60. }
  61.  
  62. gfTestHarnessCommandLineHandler.prototype = {
  63.   classDescription: "Test Harness Command Line Handler",
  64.   classID:           Components.ID("{0c1b14b2-4a2c-4ba4-bf38-0f6844439986}"),
  65.   contractID:        "@skrul.com/greasefire/testharness/commandlinehandler;1"
  66. }
  67.  
  68. gfTestHarnessCommandLineHandler.prototype.handle =
  69. function gfTestHarnessCommandLineHandler_handle(aCommandLine)
  70. {
  71.   var testPath;
  72.   try {
  73.     testPath = aCommandLine.handleFlagWithParam("test", true);
  74.   }
  75.   catch(e) {
  76.   }
  77.  
  78.   if (testPath) {
  79.     aCommandLine.preventDefault = true;
  80.     var shouldQuit = this._runTest(testPath);
  81.     if (shouldQuit) {
  82.       aCommandLine.preventDefault = true;
  83.     }
  84.     else {
  85. //      var appStartup = Cc["@mozilla.org/toolkit/app-startup;1"]
  86. //                         .getService(Ci.nsIAppStartup);
  87. //      appStartup.run();
  88.     }
  89.   }
  90. }
  91.  
  92. gfTestHarnessCommandLineHandler.prototype._runTest =
  93. function gfTestHarnessCommandLineHandler__runTest(aPath)
  94. {
  95.   var consoleService = Cc["@mozilla.org/consoleservice;1"]
  96.                          .getService(Ci.nsIConsoleService);
  97.   var consoleListener = Cc["@skrul.com/greasefire/testharness/consolelistener;1"]
  98.                           .createInstance(Ci.nsIConsoleListener);
  99.   consoleService.registerListener(consoleListener);
  100.  
  101.   var loader = Cc["@mozilla.org/moz/jssubscript-loader;1"]
  102.                  .getService(Ci.mozIJSSubScriptLoader);
  103.  
  104.   var o = new gfTestHarnessRunEnvironment();
  105.   var shouldQuit = true;
  106.  
  107.   var url = "chrome://greasefire/content/test/" + aPath;
  108.   consoleService.logStringMessage("Running test at '" + url + "'");
  109.  
  110.   try {
  111.     loader.loadSubScript(url, o);
  112.     shouldQuit = !o.runTest();
  113.     consoleService.logStringMessage("PASSED");
  114.   }
  115.   catch(e) {
  116.     consoleService.logStringMessage("FAILED");
  117.     Components.utils.reportError(e);
  118.     var stack = e.location;
  119.     while (stack) {
  120.       dump("  " + stack + "\n");
  121.       stack = stack.caller;
  122.     }
  123.   }
  124.  
  125.   return shouldQuit;
  126. }
  127.  
  128. gfTestHarnessCommandLineHandler.prototype.__defineGetter__("helpinfo",
  129. function gfTestHarnessCommandLineHandler_helpinfo()
  130. {
  131.   return "Halp!";
  132. });
  133.  
  134. function gfTestHarnessConsoleListener()
  135. {
  136. }
  137.  
  138. gfTestHarnessConsoleListener.prototype = {
  139.   classDescription: "Test Harness Console Listener",
  140.   classID:           Components.ID("{52b17aee-2705-42e0-bf2d-92afb900c4c8}"),
  141.   contractID:        "@skrul.com/greasefire/testharness/consolelistener;1",
  142.   observe: function(aMessage) {
  143.     dump("[console] " + aMessage.message + "\n");
  144.   }
  145. }
  146.  
  147. function HEX(n) {
  148.   var s = n.toString(16);
  149.   if (s.length == 1) {
  150.     s = "0" + s;
  151.   }
  152.   return s;
  153. }
  154.  
  155. /*
  156.  * ***** BEGIN LICENSE BLOCK *****
  157.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  158.  *
  159.  * The contents of this file are subject to the Mozilla Public License Version
  160.  * 1.1 (the "License"); you may not use this file except in compliance with
  161.  * the License. You may obtain a copy of the License at
  162.  * http://www.mozilla.org/MPL/
  163.  *
  164.  * Software distributed under the License is distributed on an "AS IS" basis,
  165.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  166.  * for the specific language governing rights and limitations under the
  167.  * License.
  168.  *
  169.  * The Original Code is Mozilla code.
  170.  *
  171.  * The Initial Developer of the Original Code is
  172.  * Netscape Communications Corporation.
  173.  * Portions created by the Initial Developer are Copyright (C) 2004
  174.  * the Initial Developer. All Rights Reserved.
  175.  *
  176.  * Contributor(s):
  177.  *    Alex Fritze <alex@croczilla.com> (original author)
  178.  *    Nickolay Ponomarev <asqueella@gmail.com>
  179.  *
  180.  * Alternatively, the contents of this file may be used under the terms of
  181.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  182.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  183.  * in which case the provisions of the GPL or the LGPL are applicable instead
  184.  * of those above. If you wish to allow use of your version of this file only
  185.  * under the terms of either the GPL or the LGPL, and not to allow others to
  186.  * use your version of this file under the terms of the MPL, indicate your
  187.  * decision by deleting the provisions above and replace them with the notice
  188.  * and other provisions required by the GPL or the LGPL. If you do not delete
  189.  * the provisions above, a recipient may use your version of this file under
  190.  * the terms of any one of the MPL, the GPL or the LGPL.
  191.  *
  192.  * ***** END LICENSE BLOCK ***** */
  193.  
  194. /**
  195.  * Utilities for JavaScript components loaded by the JS component
  196.  * loader.
  197.  *
  198.  * Import into a JS component using
  199.  * 'Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");'
  200.  *
  201.  * Exposing a JS 'class' as a component using these utility methods consists
  202.  * of several steps:
  203.  * 0. Import XPCOMUtils, as described above.
  204.  * 1. Declare the 'class' (or multiple classes) implementing the component(s):
  205.  *  function MyComponent() {
  206.  *    // constructor
  207.  *  }
  208.  *  MyComponent.prototype = {
  209.  *    // properties required for XPCOM registration:
  210.  *    classDescription: "unique text description",
  211.  *    classID:          Components.ID("{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}"),
  212.  *    contractID:       "@example.com/xxx;1",
  213.  *
  214.  *    // [optional] custom factory (an object implementing nsIFactory). If not
  215.  *    // provided, the default factory is used, which returns
  216.  *    // |(new MyComponent()).QueryInterface(iid)| in its createInstance().
  217.  *    _xpcom_factory: { ... },
  218.  *
  219.  *    // [optional] an array of categories to register this component in.
  220.  *    _xpcom_categories: [{
  221.  *      // Each object in the array specifies the parameters to pass to
  222.  *      // nsICategoryManager.addCategoryEntry(). 'true' is passed for
  223.  *      // both aPersist and aReplace params.
  224.  *      category: "some-category",
  225.  *      // optional, defaults to the object's classDescription
  226.  *      entry: "entry name",
  227.  *      // optional, defaults to the object's contractID (unless
  228.  *      // 'service' is specified)
  229.  *      value: "...",
  230.  *      // optional, defaults to false. When set to true, and only if 'value'
  231.  *      // is not specified, the concatenation of the string "service," and the
  232.  *      // object's contractID is passed as aValue parameter of addCategoryEntry.
  233.  *      service: true
  234.  *    }],
  235.  *
  236.  *    // QueryInterface implementation, e.g. using the generateQI helper
  237.  *    QueryInterface: XPCOMUtils.generateQI(
  238.  *      [Components.interfaces.nsIObserver,
  239.  *       Components.interfaces.nsIMyInterface]),
  240.  *
  241.  *    // ...component implementation...
  242.  *  };
  243.  *
  244.  * 2. Create an array of component constructors (like the one
  245.  * created in step 1):
  246.  *  var components = [MyComponent];
  247.  *
  248.  * 3. Define the NSGetModule entry point:
  249.  *  function NSGetModule(compMgr, fileSpec) {
  250.  *    // components is the array created in step 2.
  251.  *    return XPCOMUtils.generateModule(components);
  252.  *  }
  253.  */
  254.  
  255. var XPCOMUtils = {
  256.   /**
  257.    * Generate a QueryInterface implementation. The returned function must be
  258.    * assigned to the 'QueryInterface' property of a JS object. When invoked on
  259.    * that object, it checks if the given iid is listed in the |interfaces|
  260.    * param, and if it is, returns |this| (the object it was called on).
  261.    */
  262.   generateQI: function(interfaces) {
  263.     return makeQI([i.name for each(i in interfaces)]);
  264.   },
  265.  
  266.   /**
  267.    * Generate the NSGetModule function (along with the module definition).
  268.    * See the parameters to generateModule.
  269.    */
  270.   generateNSGetModule: function(componentsArray, postRegister, preUnregister) {
  271.     return function NSGetModule(compMgr, fileSpec) {
  272.       return XPCOMUtils.generateModule(componentsArray,
  273.                                        postRegister,
  274.                                        preUnregister);
  275.     }
  276.   },
  277.  
  278.   /**
  279.    * Generate a module implementation.
  280.    *
  281.    * @param componentsArray  Array of component constructors. See the comment
  282.    *                         at the top of this file for details.
  283.    * @param postRegister  optional post-registration function with
  284.    *                      signature 'postRegister(nsIComponentManager,
  285.    *                                              nsIFile, componentsArray)'
  286.    * @param preUnregister optional pre-unregistration function with
  287.    *                      signature 'preUnregister(nsIComponentManager,
  288.    *                                               nsIFile, componentsArray)'
  289.    */
  290.   generateModule: function(componentsArray, postRegister, preUnregister) {
  291.     let classes = [];
  292.     for each (let component in componentsArray) {
  293.       classes.push({
  294.         cid:          component.prototype.classID,
  295.         className:    component.prototype.classDescription,
  296.         contractID:   component.prototype.contractID,
  297.         factory:      this._getFactory(component),
  298.         categories:   component.prototype._xpcom_categories
  299.       });
  300.     }
  301.  
  302.     return { // nsIModule impl.
  303.       getClassObject: function(compMgr, cid, iid) {
  304.         // We only support nsIFactory queries, not nsIClassInfo
  305.         if (!iid.equals(Ci.nsIFactory))
  306.           throw Cr.NS_ERROR_NOT_IMPLEMENTED;
  307.  
  308.         for each (let classDesc in classes) {
  309.           if (classDesc.cid.equals(cid))
  310.             return classDesc.factory;
  311.         }
  312.  
  313.         throw Cr.NS_ERROR_FACTORY_NOT_REGISTERED;
  314.       },
  315.  
  316.       registerSelf: function(compMgr, fileSpec, location, type) {
  317.         var componentCount = 0;
  318.         debug("*** registering " + fileSpec.leafName + ": [ ");
  319.         compMgr.QueryInterface(Ci.nsIComponentRegistrar);
  320.  
  321.         for each (let classDesc in classes) {
  322.           debug((componentCount++ ? ", " : "") + classDesc.className);
  323.           compMgr.registerFactoryLocation(classDesc.cid,
  324.                                           classDesc.className,
  325.                                           classDesc.contractID,
  326.                                           fileSpec,
  327.                                           location,
  328.                                           type);
  329.           if (classDesc.categories) {
  330.             let catMan = XPCOMUtils.categoryManager;
  331.             for each (let cat in classDesc.categories) {
  332.               let defaultValue = (cat.service ? "service," : "") +
  333.                                  classDesc.contractID;
  334.               catMan.addCategoryEntry(cat.category,
  335.                                       cat.entry || classDesc.className,
  336.                                       cat.value || defaultValue,
  337.                                       true, true);
  338.             }
  339.           }
  340.         }
  341.  
  342.         if (postRegister)
  343.           postRegister(compMgr, fileSpec, componentsArray);
  344.         debug(" ]\n");
  345.       },
  346.  
  347.       unregisterSelf: function(compMgr, fileSpec, location) {
  348.         var componentCount = 0;
  349.         debug("*** unregistering " + fileSpec.leafName + ": [ ");
  350.         compMgr.QueryInterface(Ci.nsIComponentRegistrar);
  351.         if (preUnregister)
  352.           preUnregister(compMgr, fileSpec, componentsArray);
  353.  
  354.         for each (let classDesc in classes) {
  355.           debug((componentCount++ ? ", " : "") + classDesc.className);
  356.           if (classDesc.categories) {
  357.             let catMan = XPCOMUtils.categoryManager;
  358.             for each (let cat in classDesc.categories) {
  359.               catMan.deleteCategoryEntry(cat.category,
  360.                                          cat.entry || classDesc.className,
  361.                                          true);
  362.             }
  363.           }
  364.           compMgr.unregisterFactoryLocation(classDesc.cid, fileSpec);
  365.         }
  366.         debug(" ]\n");
  367.       },
  368.  
  369.       canUnload: function(compMgr) {
  370.         return true;
  371.       }
  372.     };
  373.   },
  374.  
  375.   /**
  376.    * Convenience access to category manager
  377.    */
  378.   get categoryManager() {
  379.     return Components.classes["@mozilla.org/categorymanager;1"]
  380.            .getService(Ci.nsICategoryManager);
  381.   },
  382.  
  383.   /**
  384.    * Returns an nsIFactory for |component|.
  385.    */
  386.   _getFactory: function(component) {
  387.     var factory = component.prototype._xpcom_factory;
  388.     if (!factory) {
  389.       factory = {
  390.         createInstance: function(outer, iid) {
  391.           if (outer)
  392.             throw Cr.NS_ERROR_NO_AGGREGATION;
  393.           return (new component()).QueryInterface(iid);
  394.         }
  395.       }
  396.     }
  397.     return factory;
  398.   }
  399. };
  400.  
  401. /**
  402.  * Helper for XPCOMUtils.generateQI to avoid leaks - see bug 381651#c1
  403.  */
  404. function makeQI(interfaceNames) {
  405.   return function XPCOMUtils_QueryInterface(iid) {
  406.     if (iid.equals(Ci.nsISupports))
  407.       return this;
  408.     for each(let interfaceName in interfaceNames) {
  409.       if (Ci[interfaceName].equals(iid))
  410.         return this;
  411.     }
  412.  
  413.     throw Cr.NS_ERROR_NO_INTERFACE;
  414.   };
  415. }
  416.  
  417. //@line 156 "/home/steve/dev/mozilla/1.8/mozilla/extensions/greasefire/testharness/src/gfTestHarnessCommandLineHandler.js"
  418.  
  419. gfTestHarnessCommandLineHandler.prototype.QueryInterface =
  420.   XPCOMUtils.generateQI([Ci.nsICommandLineHandler]);
  421.  
  422. gfTestHarnessConsoleListener.prototype.QueryInterface =
  423.   XPCOMUtils.generateQI([Ci.nsIConsoleListener]);
  424.  
  425. var NSGetModule = XPCOMUtils.generateNSGetModule(
  426.   [
  427.     gfTestHarnessCommandLineHandler,
  428.     gfTestHarnessConsoleListener
  429.   ],
  430.   function(aCompMgr, aFileSpec, aLocation) {
  431.     XPCOMUtils.categoryManager.addCategoryEntry(
  432.       "command-line-handler",
  433.       "a-testhaness",
  434.       gfTestHarnessCommandLineHandler.prototype.contractID,
  435.       true,
  436.       true);
  437.   }
  438. );
  439.  
  440.